home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 352_01 / vector.cpp < prev    next >
C/C++ Source or Header  |  1991-04-22  |  3KB  |  198 lines
  1. // vector.cpp - trial vector program to iron out C++  8/8/90
  2.  
  3. #include <stdlib.h>
  4. #include <alloc.h>
  5. #include <string.h>
  6. #include "wtwg.h"
  7.  
  8. #include "dblib.h"
  9.  
  10. #include "vector.h"
  11.  
  12.  
  13.  
  14.     Vector::Vector(int k)            // constructor
  15.         {
  16.         int nb = k*sizeof(float);
  17.         if ( k>0 )
  18.             {
  19.             n=k;
  20.             v=(float*)wmalloc(nb, "Vector");
  21.             memset ( v, 0 ,nb );
  22.             }
  23.         else
  24.             {
  25.             v=NULL;            // allow zero length vectors
  26.             n=0;
  27.             }
  28.         }
  29.  
  30.     Vector::Vector( Vector& vec)        // copy constructor
  31.         {
  32.         n = vec.n;
  33.         int nb =(n*sizeof(float));
  34.         v =(float*)wmalloc(nb, "Vector");
  35.         memcpy ( v, vec.v, nb );
  36.         }
  37.  
  38.     Vector::~Vector() { if ( n>0 ) free (v); }
  39.  
  40.     void Vector::realloc ( int nitems )
  41.         // change size of a vector.
  42.         {
  43.         int old_nb = n * sizeof (float);
  44.         float *old_v = v;
  45.         
  46.         n = nitems;
  47.         if ( n>0 )
  48.             {
  49.             register int new_nb = nitems * sizeof (float);
  50.             v = (float *)wmalloc ( new_nb, "Vector");
  51.             memset ( v, 0, new_nb );
  52.             memcpy ( v, old_v, min ( new_nb, old_nb ) );
  53.             }
  54.         else
  55.             {
  56.             v =NULL;
  57.             }
  58.         if ( old_nb > 0 ) free (old_v);
  59.         }
  60.  
  61.     Vector& Vector::operator=(Vector& vec)        // assign one V to another
  62.         {
  63.         int  vecn = vec.n;
  64.         
  65.         if ( n == 0 )  realloc (vecn);        // if target is zero len...
  66.     
  67.         int vn = n;
  68.         
  69.         int nt  = min ( vn, vecn );
  70.         
  71.         float *vv = v;
  72.         memcpy ( vv, vec.v, nt*sizeof(float) );
  73.         
  74.         // if target longer than source, fill in remainder with zeros.
  75.         while ( nt++ < vn )        
  76.             {
  77.             vv[nt] = 0;;
  78.             }
  79.         
  80.         return *this;
  81.         }
  82.  
  83.  
  84.     Vector& Vector::operator=(float x)
  85.         // assign float x to vector
  86.         {
  87.         int vn =n;
  88.         float *vv =v;
  89.         while ( --vn >= 0 )
  90.             {
  91.             vv[vn] = x;
  92.             }
  93.         return *this;
  94.         }
  95.  
  96.  
  97.     Vector& Vector::operator+=(Vector&  x)
  98.         // add Vector x to Vector this.
  99.         {
  100.         int  k = min ( x.n, n );    // use smaller Vector for range.
  101.         float *tv = v, *xv = x.v;
  102.         while ( --k >= 0 )
  103.             {
  104.             tv[k] += xv[k];
  105.             }
  106.         return *this;
  107.         }
  108.  
  109.  
  110.     Vector& Vector::operator+=(float  x)
  111.         // add float x to Vector this.
  112.         {
  113.         int k =n;
  114.         float *tv = v;
  115.         while ( --k >= 0 )
  116.             {
  117.             tv[k] += x;
  118.             }
  119.         return *this;
  120.         }
  121.  
  122.  
  123.     Vector& Vector::operator*=(Vector&  x)
  124.         // multiply Vector this by Vector x.
  125.         {
  126.         int  k = min ( x.n, n );    // use smaller Vector for range.
  127.         float *tv = v,  *xv =x.v;
  128.         while  ( --k >= 0 )
  129.             {
  130.             tv[k] *= xv[k];
  131.             }
  132.         return *this;
  133.         }
  134.  
  135.  
  136.     Vector& Vector::operator*=(float  x)
  137.         // Multiply Vector this by float x
  138.         {
  139.         int k =n;
  140.         float *tv =v;
  141.         while ( --k >= 0 )
  142.             {
  143.             tv[k] *= x;
  144.             }
  145.         return *this;
  146.         }
  147.  
  148.     Vector& Vector::operator-=(Vector&  x)
  149.         // subtract Vector x from Vector this.
  150.         {
  151.         int  k = min ( x.n, n );    // use smaller Vector for range.
  152.         float *tv =v, *xv =x.v;
  153.         while ( --k >= 0 )
  154.             {
  155.             tv[k] -= xv[k];
  156.             }
  157.         return *this;
  158.         }
  159.  
  160.  
  161.     Vector& Vector::operator-=(float  x)
  162.         // Subtract float x from Vector this
  163.         {
  164.         int k =n;
  165.         float *tv =v;
  166.         while ( --k >= 0 )
  167.             {
  168.             tv[k] -= x;
  169.             }
  170.         return *this;
  171.         }
  172.  
  173.     Vector& Vector::operator/=(float  x)
  174.         // Divide Vector x by float x. NOTE prevents divide by zero.
  175.         {
  176.         int k =n;
  177.         float *tv =v;
  178.         if ( x > -MINFLOAT*10  && x< MINFLOAT*10 )
  179.             {
  180.             while ( --k >= 0 )
  181.                 {
  182.                 tv[k] = MAXFLOAT/10;
  183.                 }
  184.             }
  185.         else
  186.             {
  187.             while ( --k >= 0 )
  188.                 {
  189.                 tv[k] /= x;
  190.                 }
  191.             }
  192.         return *this;
  193.         }
  194.  
  195.  
  196. //--------------------  end of VECTOR.CPP -------------------- 
  197.  
  198.